use anyhow::Result;
use std::io::{BufRead, BufReader, Write};
use std::net::TcpStream;
use std::time::Duration;

/// 简单的FTP客户端用于测试
pub struct FtpTestClient {
    control_stream: TcpStream,
    reader: BufReader<TcpStream>,
}

impl FtpTestClient {
    /// 连接到FTP服务器
    pub fn connect(host: &str, port: u16) -> Result<Self> {
        let stream = TcpStream::connect(format!("{}:{}", host, port))?;
        let reader = BufReader::new(stream.try_clone()?);
        
        Ok(Self {
            control_stream: stream,
            reader,
        })
    }
    
    /// 发送FTP命令
    pub fn send_command(&mut self, command: &str) -> Result<()> {
        println!(">>> {}", command);
        self.control_stream.write_all(format!("{}\r\n", command).as_bytes())?;
        self.control_stream.flush()?;
        Ok(())
    }
    
    /// 读取FTP响应
    pub fn read_response(&mut self) -> Result<String> {
        let mut line = String::new();
        self.reader.read_line(&mut line)?;
        let response = line.trim_end_matches("\r\n").to_string();
        println!("<<< {}", response);
        Ok(response)
    }
    
    /// 等待响应并检查状态码
    pub fn expect_response(&mut self, expected_code: u16) -> Result<String> {
        let response = self.read_response()?;
        let code: u16 = response.split_whitespace().next()
            .and_then(|s| s.parse().ok())
            .unwrap_or(0);
        
        if code == expected_code {
            Ok(response)
        } else {
            Err(anyhow::anyhow!("Expected code {}, got {}", expected_code, code))
        }
    }
    
    /// 登录到FTP服务器
    pub fn login(&mut self, username: &str, password: &str) -> Result<()> {
        // 发送用户名
        self.send_command(&format!("USER {}", username))?;
        self.expect_response(331)?; // User name okay, need password
        
        // 发送密码
        self.send_command(&format!("PASS {}", password))?;
        self.expect_response(230)?; // User logged in
        
        Ok(())
    }
    
    /// 测试PASV模式
    pub fn test_pasv(&mut self) -> Result<()> {
        println!("\n=== 测试PASV模式 ===");
        
        self.send_command("PASV")?;
        let response = self.expect_response(227)?; // Entering Passive Mode
        
        // 解析PASV响应中的IP和端口
        if let Some(start) = response.find('(') {
            if let Some(end) = response.find(')') {
                let pasv_info = &response[start+1..end];
                println!("PASV信息: {}", pasv_info);
            }
        }
        
        Ok(())
    }
    
    /// 测试PORT模式
    pub fn test_port(&mut self) -> Result<()> {
        println!("\n=== 测试PORT模式 ===");
        
        // 使用本地IP和随机端口
        self.send_command("PORT 127,0,0,1,4,210")?;
        self.expect_response(200)?; // Command okay
        
        Ok(())
    }
    
    /// 测试系统信息
    pub fn test_system_info(&mut self) -> Result<()> {
        println!("\n=== 测试系统信息 ===");
        
        // 测试SYST命令
        self.send_command("SYST")?;
        self.expect_response(215)?; // System type
        
        // 测试FEAT命令
        self.send_command("FEAT")?;
        self.expect_response(211)?; // Features
        
        // 测试NOOP命令
        self.send_command("NOOP")?;
        self.expect_response(200)?; // Command okay
        
        Ok(())
    }
    
    /// 测试目录操作
    pub fn test_directory_operations(&mut self) -> Result<()> {
        println!("\n=== 测试目录操作 ===");
        
        // 测试PWD命令
        self.send_command("PWD")?;
        self.expect_response(257)?; // Pathname created
        
        // 测试CWD命令
        self.send_command("CWD /")?;
        self.expect_response(250)?; // Requested file action okay
        
        // 测试CDUP命令
        self.send_command("CDUP")?;
        self.expect_response(250)?; // Requested file action okay
        
        // 测试MKD命令
        self.send_command("MKD testdir")?;
        self.expect_response(257)?; // Pathname created
        
        // 测试RMD命令
        self.send_command("RMD testdir")?;
        self.expect_response(250)?; // Requested file action okay
        
        Ok(())
    }
    
    /// 测试文件操作
    pub fn test_file_operations(&mut self) -> Result<()> {
        println!("\n=== 测试文件操作 ===");
        
        // 测试LIST命令
        self.send_command("LIST")?;
        self.expect_response(150)?; // Data connection already open
        
        // 测试NLST命令
        self.send_command("NLST")?;
        self.expect_response(150)?; // Data connection already open
        
        // 测试SIZE命令
        self.send_command("SIZE testfile.txt")?;
        // 可能返回550 (File not found) 或 213 (File status)
        let response = self.read_response()?;
        println!("SIZE响应: {}", response);
        
        // 测试MDTM命令
        self.send_command("MDTM testfile.txt")?;
        // 可能返回550 (File not found) 或 213 (File status)
        let response = self.read_response()?;
        println!("MDTM响应: {}", response);
        
        Ok(())
    }
    
    /// 测试传输模式
    pub fn test_transfer_modes(&mut self) -> Result<()> {
        println!("\n=== 测试传输模式 ===");
        
        // 测试TYPE命令
        self.send_command("TYPE A")?;
        self.expect_response(200)?; // Command okay
        
        self.send_command("TYPE I")?;
        self.expect_response(200)?; // Command okay
        
        // 测试REST命令
        self.send_command("REST 0")?;
        self.expect_response(350)?; // Requested file action pending further information
        
        Ok(())
    }
    
    /// 测试文件传输
    pub fn test_file_transfer(&mut self) -> Result<()> {
        println!("\n=== 测试文件传输 ===");
        
        // 设置PASV模式
        self.test_pasv()?;
        
        // 测试STOR命令
        self.send_command("STOR testfile.txt")?;
        self.expect_response(150)?; // Data connection already open
        
        // 测试RETR命令
        self.send_command("RETR testfile.txt")?;
        self.expect_response(150)?; // Data connection already open
        
        // 测试APPE命令
        self.send_command("APPE testfile.txt")?;
        self.expect_response(150)?; // Data connection already open
        
        Ok(())
    }
    
    /// 运行完整测试
    pub fn run_full_test(&mut self) -> Result<()> {
        println!("🚀 开始FTP服务器功能测试");
        
        // 测试系统信息
        self.test_system_info()?;
        
        // 测试用户认证（使用测试用户）
        println!("\n=== 测试用户认证 ===");
        match self.login("testuser", "testpass") {
            Ok(_) => println!("✅ 用户认证成功"),
            Err(e) => println!("❌ 用户认证失败: {}", e),
        }
        
        // 测试传输模式
        self.test_transfer_modes()?;
        
        // 测试PASV模式
        self.test_pasv()?;
        
        // 测试PORT模式
        self.test_port()?;
        
        // 测试目录操作
        self.test_directory_operations()?;
        
        // 测试文件操作
        self.test_file_operations()?;
        
        // 测试文件传输
        self.test_file_transfer()?;
        
        // 退出
        println!("\n=== 退出测试 ===");
        self.send_command("QUIT")?;
        self.expect_response(221)?; // Service closing control connection
        
        println!("✅ 所有测试完成！");
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]
    fn test_ftp_connection() {
        // 这个测试需要FTP服务器运行
        // 在实际测试中，需要先启动FTP服务器
        println!("注意：此测试需要FTP服务器运行在localhost:21");
    }
}
